home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / lisp / kcl / akcl / kcl.lha / c / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  14.6 KB  |  905 lines
  1. /*
  2. (c) Copyright Taiichi Yuasa and Masami Hagiya, 1984.  All rights reserved.
  3. Copying of this file is authorized to users who have executed the true and
  4. proper "License Agreement for Kyoto Common LISP" with SIGLISP.
  5. */
  6.  
  7. /*
  8.     main.c
  9.     IMPLEMENTATION-DEPENDENT
  10. */
  11.  
  12. #include "include.h"
  13.  
  14. bool saving_system = FALSE;
  15.  
  16. #ifdef BSD
  17. #include <sys/time.h>
  18. #include <sys/resource.h>
  19. #endif
  20.  
  21. #ifdef AOSVS
  22.  
  23. #endif
  24.  
  25. #define    MAXPATHLEN    1024
  26.  
  27. char lisp_implementation_version[] = "June 1987";
  28.  
  29. char system_directory[MAXPATHLEN];
  30. object siVsystem_directory;
  31. #ifdef UNIX
  32. char *kcl_self;
  33. #endif
  34.  
  35. char stdin_buf[BUFSIZ];
  36. char stdout_buf[BUFSIZ];
  37.  
  38. int debug;            /* debug switch */
  39. int initflag = FALSE;        /* initialized flag */
  40.  
  41. int real_maxpage;
  42. object siVlisp_maxpages;
  43.  
  44. object siClisp_pagesize;
  45.  
  46. object siStop_level;
  47.  
  48. int ARGC;
  49. char **ARGV;
  50. #ifdef UNIX
  51. char **ENVP;
  52. #endif
  53.  
  54. static object defmacro_data;
  55. static object evalmacros_data;
  56. static object top_data;
  57. static object module_data;
  58.  
  59. char *merge_system_directory();
  60.  
  61. int cssize;
  62.  
  63. #ifdef UNIX
  64. main(argc, argv, envp) 
  65. int argc;
  66. char **argv, **envp;
  67. #else
  68. main(argc, argv)
  69. int argc;
  70. char **argv;
  71. #endif
  72. {
  73.     FILE *i;
  74. #ifdef BSD
  75.     struct rlimit rl;
  76. #endif
  77. #ifdef AOSVS
  78.  
  79.  
  80.  
  81. #endif
  82.  
  83.     setbuf(stdin, stdin_buf);
  84.     setbuf(stdout, stdout_buf);
  85.  
  86.     ARGC = argc;
  87.     ARGV = argv;
  88. #ifdef UNIX
  89.     ENVP = envp;
  90. #endif
  91.  
  92. #ifdef UNIX
  93. /*
  94.     if (argv[0][0] != '/')
  95.         error("can't get the program name");
  96. */
  97.     kcl_self = argv[0];
  98.     if (!initflag) {
  99.         strcpy(system_directory, argv[0]);
  100.         if (system_directory[0] != '/')
  101.             strcpy(system_directory, "./");
  102.         else {
  103.             int j;
  104.  
  105.             for (j = strlen(system_directory);
  106.                              system_directory[j-1] != '/';  --j)
  107.                 ;
  108.             system_directory[j] = '\0';
  109.         }
  110.     }
  111. #endif
  112. #ifdef AOSVS
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125. #endif
  126.  
  127.     if (!initflag && argc > 1) {
  128. #ifdef UNIX
  129.         if (argv[1][strlen(argv[1])-1] != '/')
  130. #endif
  131. #ifdef AOSVS
  132.  
  133. #endif
  134.             error("can't get the system directory");
  135.         strcpy(system_directory, argv[1]);
  136.     }
  137.  
  138.     GBC_enable = FALSE;
  139.  
  140.     vs_top = vs_base = vs_org;
  141.     vs_limit = &vs_org[VSSIZE];
  142.     frs_top = frs_org-1;
  143.     frs_limit = &frs_org[FRSSIZE];
  144.     bds_top = bds_org-1;
  145.     bds_limit = &bds_org[BDSSIZE];
  146.       ihs_top = ihs_org-1;
  147.     ihs_limit = &ihs_org[IHSSIZE];
  148.     cs_org = &argc;
  149.  
  150.     cssize = CSSIZE;
  151.  
  152. #ifdef BSD
  153.     getrlimit(RLIMIT_STACK, &rl);
  154.     cssize = rl.rlim_cur/4 - 4*CSGETA;
  155. #endif
  156.  
  157. #ifdef AV
  158.     cs_limit = cs_org - cssize;
  159. #endif
  160. #ifdef MV
  161.  
  162. #endif
  163.  
  164.     set_maxpage();
  165.  
  166.     if (initflag) {
  167.         if (saving_system) {
  168.             saving_system = FALSE;
  169.             alloc_page(-(holepage + nrbpage));
  170.         }
  171.  
  172.         initflag = FALSE;
  173.         GBC_enable = TRUE;
  174.         vs_base = vs_top;
  175.         ihs_push(Cnil);
  176.         lex_new();
  177.         vs_base = vs_top;
  178. #ifdef AOSVS
  179.  
  180.  
  181. #endif
  182.         interrupt_enable = TRUE;
  183. #ifdef UNIX
  184.         init_interrupt();
  185. #endif
  186.         siVlisp_maxpages->s.s_dbind = make_fixnum(real_maxpage);
  187.         initflag = TRUE;
  188.         super_funcall(siStop_level);
  189.         exit(0);
  190.     }
  191.  
  192.     printf("KCl (Kyoto Common Lisp)  %s  %d pages\n",
  193.            lisp_implementation_version,
  194.            MAXPAGE);
  195.     fflush(stdout);
  196.  
  197.     init();
  198.  
  199.     vs_base = vs_top;
  200.     ihs_push(Cnil);
  201.     lex_new();
  202.  
  203.     GBC_enable = TRUE;
  204.  
  205.     CMPtemp = CMPtemp1 = CMPtemp2 = CMPtemp3 = OBJNULL;
  206.  
  207.     init_init();
  208.  
  209.     Vpackage->s.s_dbind = user_package;
  210.  
  211.     lex_new();
  212.     vs_base = vs_top;
  213.     initflag = TRUE;
  214.  
  215.     interrupt_enable = TRUE;
  216. #ifdef UNIX
  217.     init_interrupt();
  218. #endif
  219.  
  220. /*  Primitive read-eval-print loop for debugging.  */
  221. /*
  222.     for (;;) {
  223.         vs_base = vs_top;
  224.         vs_push(code_char('>'));
  225.         Lwrite_char();
  226.         vs_base = vs_top;
  227.         Lfinish_output();
  228.         vs_base = vs_top;
  229.         Lread();
  230.         Leval();
  231.         vs_top = vs_base+1;
  232.         Lprin1();
  233.         vs_base = vs_top;
  234.         Lterpri();
  235.     }
  236. */
  237.  
  238. /*  Now, init.lsp is loaded by si:top-level.  */
  239. /*
  240. #ifdef UNIX
  241.     if ((i = fopen("./init.lsp", "r")) != NULL) {
  242.         fclose(i);
  243.         load("./init.lsp");
  244.     }
  245. #endif
  246. #ifdef AOSVS
  247.  
  248.  
  249.  
  250.  
  251. #endif
  252. */
  253.  
  254.     super_funcall(siStop_level);
  255.  
  256. }
  257.  
  258. init()
  259. {
  260.     int j;
  261.  
  262.     init_alloc();
  263.  
  264.     Cnil_body.t = (short)t_symbol;
  265.     Cnil_body.s_dbind = Cnil;
  266.     Cnil_body.s_sfdef = NOT_SPECIAL;
  267.     Cnil_body.s_fillp = 3;
  268.     Cnil_body.s_self = "NIL";
  269.     Cnil_body.s_gfdef = OBJNULL;
  270.     Cnil_body.s_plist = Cnil;
  271.     Cnil_body.s_hpack = Cnil;
  272.     Cnil_body.s_stype = (short)stp_constant;
  273.     Cnil_body.s_mflag = FALSE;
  274.     
  275.     Ct_body.t = (short)t_symbol;
  276.     Ct_body.s_dbind = Ct;
  277.     Ct_body.s_sfdef = NOT_SPECIAL;
  278.     Ct_body.s_fillp = 1;
  279.     Ct_body.s_self = "T";
  280.     Ct_body.s_gfdef = OBJNULL;
  281.     Ct_body.s_plist = Cnil;
  282.     Ct_body.s_hpack = Cnil;
  283.     Ct_body.s_stype = (short)stp_constant;
  284.     Ct_body.s_mflag = FALSE;
  285.     
  286.     init_symbol();
  287.  
  288.     init_package();
  289.  
  290.     Cnil->s.s_hpack = lisp_package;
  291.     import(Cnil, lisp_package);
  292.     export(Cnil, lisp_package);
  293.  
  294.     Ct->s.s_hpack = lisp_package;
  295.     import(Ct, lisp_package);
  296.     export(Ct, lisp_package);
  297.  
  298.     Squote = make_ordinary("QUOTE");
  299.     enter_mark_origin(&Squote);
  300.     Sfunction = make_ordinary("FUNCTION");
  301.     enter_mark_origin(&Sfunction);
  302.     Slambda = make_ordinary("LAMBDA");
  303.     enter_mark_origin(&Slambda);
  304.     Slambda_block = make_ordinary("LAMBDA-BLOCK");
  305.     enter_mark_origin(&Slambda_block);
  306.     Slambda_closure = make_ordinary("LAMBDA-CLOSURE");
  307.     enter_mark_origin(&Slambda_closure);
  308.     Slambda_block_closure = make_ordinary("LAMBDA-BLOCK-CLOSURE");
  309.     enter_mark_origin(&Slambda_block_closure);
  310.     Sspecial = make_ordinary("SPECIAL");
  311.     enter_mark_origin(&Sspecial);
  312.  
  313.     init_typespec();
  314.     init_number();
  315.     init_character();
  316.     init_file();
  317.     init_read();
  318.     init_bind();
  319.     init_pathname();
  320.     init_print();
  321.     init_GBC();
  322.  
  323. #ifdef UNIX
  324. #ifndef DGUX
  325.     init_unixfasl();
  326.     init_unixsys();
  327.     init_unixsave();
  328. #else
  329.  
  330.  
  331.  
  332. #endif
  333. #endif
  334.  
  335. #ifdef AOSVS
  336.  
  337.  
  338.  
  339. #endif
  340.  
  341.     init_alloc_function();
  342.     init_array_function();
  343.     init_character_function();
  344.     init_file_function();
  345.     init_list_function();
  346.     init_package_function();
  347.     init_pathname_function();
  348.     init_predicate_function();
  349.     init_print_function();
  350.     init_read_function();
  351.     init_sequence_function();
  352.     init_structure_function();
  353.     init_string_function();
  354.     init_symbol_function();
  355.     init_typespec_function();
  356.     init_hash();
  357.     init_cfun();
  358.  
  359. #ifdef UNIX
  360.     init_unixfsys();
  361.     init_unixtime();
  362. #endif
  363. #ifdef AOSVS
  364.  
  365.  
  366. #endif
  367.  
  368.     init_eval();
  369.     init_lex();
  370.     init_prog();
  371.     init_catch();
  372.     init_block();
  373.         init_macros();
  374.     init_conditional();
  375.     init_reference();
  376.     init_assignment();
  377.     init_multival();
  378.     init_error();
  379.     init_let();
  380.     init_mapfun();
  381.     init_iteration();
  382.     init_toplevel();
  383.  
  384.     init_cmpaux();
  385.  
  386.     init_main();
  387.  
  388.     init_format();
  389.  
  390. #ifdef AOSVS
  391.  
  392. #endif
  393.     init_interrupt1();
  394. }
  395.  
  396. /*  init_init is now defined in init_system.c  */
  397. /*
  398. init_init()
  399. {
  400.     load(merge_system_directory("export.lsp"));
  401.  
  402. #ifdef UNIX
  403.     defmacro_data = read_fasl_data(merge_system_directory("defmacro.o"));
  404.     enter_mark_origin(&defmacro_data);
  405.     init_defmacro(NULL, 0, defmacro_data);
  406.     evalmacros_data
  407.     = read_fasl_data(merge_system_directory("evalmacros.o"));
  408.     enter_mark_origin(&evalmacros_data);
  409.     init_evalmacros(NULL, 0, evalmacros_data);
  410.     top_data = read_fasl_data(merge_system_directory("top.o"));
  411.     enter_mark_origin(&top_data);
  412.     init_top(NULL, 0, top_data);
  413.     module_data = read_fasl_data(merge_system_directory("module.o"));
  414.     enter_mark_origin(&module_data);
  415.     init_module(NULL, 0, module_data);
  416. #endif
  417. #ifdef AOSVS
  418.  
  419.  
  420.  
  421.  
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432. #endif
  433.  
  434.     load(merge_system_directory("autoload.lsp"));
  435. }
  436. */
  437.  
  438. char *
  439. merge_system_directory(s)
  440. {
  441.     static char buff[MAXPATHLEN];
  442.     extern char *strcat();
  443.  
  444.     strcpy(buff, system_directory);
  445.     return(strcat(buff, s));
  446. }
  447.  
  448. vs_overflow()
  449. {
  450.     if (vs_limit > vs_org + VSSIZE)
  451.         error("value stack overflow");
  452.     vs_limit += VSGETA;
  453.     FEerror("Value stack overflow.", 0);
  454. }
  455.  
  456. bds_overflow()
  457. {
  458.     --bds_top;
  459.     if (bds_limit > bds_org + BDSSIZE)
  460.         error("bind stack overflow");
  461.     bds_limit += BDSGETA;
  462.     FEerror("Bind stack overflow.", 0);
  463. }
  464.  
  465. frs_overflow()
  466. {
  467.     --frs_top;
  468.     if (frs_limit > frs_org + FRSSIZE)
  469.         error("frame stack overflow");
  470.     frs_limit += FRSGETA;
  471.     FEerror("Frame stack overflow.", 0);
  472. }
  473.  
  474. ihs_overflow()
  475. {
  476.     --ihs_top;
  477.     if (ihs_limit > ihs_org + IHSSIZE)
  478.         error("invocation history stack overflow");
  479.     ihs_limit += IHSGETA;
  480.     FEerror("Invocation history stack overflow.", 0);
  481. }
  482.  
  483. cs_overflow()
  484. {
  485. #ifdef AV
  486.     if (cs_limit < cs_org - cssize)
  487.         error("control stack overflow");
  488.     cs_limit -= CSGETA;
  489. #endif
  490. #ifdef MV
  491.  
  492.  
  493.  
  494. #endif
  495.     FEerror("Control stack overflow.", 0);
  496. }
  497.  
  498. end_of_file()
  499. {
  500.     error("end of file");
  501. }
  502.  
  503. error(s)
  504. {
  505.     printf("\nUnrecoverable error: %s.\n", s);
  506.     fflush(stdout);
  507. #ifdef UNIX
  508.     abort();
  509. #endif
  510. #ifdef AOSVS
  511.  
  512. #endif
  513. }
  514.  
  515. Lby()
  516. {
  517. #ifdef UNIX
  518.     int i;
  519.  
  520.     if (vs_top - vs_base == 0)
  521.         i = 0;
  522.     else if (vs_top - vs_base == 1) {
  523.         if (type_of(vs_base[0]) == t_fixnum)
  524.             i = fix(vs_base[0]);
  525.         else
  526.             FEerror("Illegal exit code: ~S.", 1, vs_base[0]);
  527.     } else
  528.         too_many_arguments();
  529.     printf("Bye.\n");
  530.     exit(i);
  531. #endif
  532. #ifdef AOSVS
  533.  
  534.  
  535.  
  536.  
  537.  
  538.  
  539.  
  540.  
  541.  
  542.  
  543.  
  544.  
  545.  
  546.  
  547.  
  548.  
  549.  
  550.  
  551.  
  552.  
  553.  
  554.  
  555. #endif
  556. }
  557.  
  558. c_trace()
  559. {
  560. #ifdef AOSVS
  561.  
  562. #endif
  563. }
  564.  
  565. siLargc()
  566. {
  567.     check_arg(0);
  568.     vs_push(make_fixnum(ARGC));
  569. }
  570.  
  571. siLargv()
  572. {
  573.     int i;
  574.  
  575.     check_arg(1);
  576.     if (type_of(vs_base[0]) != t_fixnum ||
  577.         (i = fix(vs_base[0])) < 0 ||
  578.         i >= ARGC)
  579.         FEerror("Illegal argument index: ~S.", 1, vs_base[0]);
  580.     vs_base[0] = make_simple_string(ARGV[i]);
  581. }
  582.  
  583. #ifdef UNIX
  584. siLgetenv()
  585. {
  586.     char name[256];
  587.     int i;
  588.     char *value;
  589.     extern char *getenv();
  590.  
  591.     check_arg(1);
  592.     check_type_string(&vs_base[0]);
  593.     if (vs_base[0]->st.st_fillp >= 256)
  594.         FEerror("Too long name: ~S.", 1, vs_base[0]);
  595.     for (i = 0;  i < vs_base[0]->st.st_fillp;  i++)
  596.         name[i] = vs_base[0]->st.st_self[i];
  597.     name[i] = '\0';
  598.     if ((value = getenv(name)) != NULL)
  599.         vs_base[0] = make_simple_string(value);
  600.     else
  601.         vs_base[0] = Cnil;
  602. }
  603. #endif
  604.  
  605. object *vs_marker;
  606.  
  607. siLmark_vs()
  608. {
  609.     check_arg(0);
  610.     vs_marker = vs_base;
  611.     vs_base[0] = Cnil;
  612. }
  613.  
  614. siLcheck_vs()
  615. {
  616.     check_arg(0);
  617.     if (vs_base != vs_marker)
  618.         FEerror("Value stack is flawed.", 0);
  619.     vs_base[0] = Cnil;
  620. }
  621.  
  622. siLreset_stack_limits(arg)
  623. {
  624.     check_arg(0);
  625.     if (vs_top < vs_org + VSSIZE)
  626.         vs_limit = vs_org + VSSIZE;
  627.     else
  628.         error("can't reset vs_limit");
  629.     if (bds_top < bds_org + BDSSIZE)
  630.         bds_limit = bds_org + BDSSIZE;
  631.     else
  632.         error("can't reset bds_limit");
  633.     if (frs_top < frs_org + FRSSIZE)
  634.         frs_limit = frs_org + FRSSIZE;
  635.     else
  636.         error("can't reset frs_limit");
  637.     if (ihs_top < ihs_org + IHSSIZE)
  638.         ihs_limit = ihs_org + IHSSIZE;
  639.     else
  640.         error("can't reset ihs_limit");
  641. #ifdef AV
  642.     if (&arg > cs_org - cssize + 16)
  643.         cs_limit = cs_org - cssize;
  644. #endif
  645. #ifdef MV
  646.  
  647.  
  648. #endif
  649.     else
  650.         error("can't reset cs_limit");
  651.     vs_base[0] = Cnil;
  652. }
  653.  
  654. siLinit_system()
  655. {
  656.     check_arg(0);
  657.     init_system();
  658.     vs_base[0] = Cnil;
  659. }
  660.  
  661. siLaddress()
  662. {
  663.     check_arg(1);
  664.     vs_base[0] = make_fixnum((int)vs_base[0]);
  665. }
  666.  
  667. siLnani()
  668. {
  669.     check_arg(1);
  670.     vs_base[0] = (object)fixint(vs_base[0]);
  671. }
  672.  
  673. siLinitialization_failure()
  674. {
  675.     check_arg(0);
  676.     printf("lisp initialization failed\n");
  677.     exit(0);
  678. }
  679.  
  680. Lidentity()
  681. {
  682.     check_arg(1);
  683. }
  684.  
  685. Llisp_implementation_version()
  686. {
  687.     check_arg(0);
  688.     vs_push(make_simple_string(lisp_implementation_version));
  689.     vs_base[0] = Cnil;
  690. }
  691.  
  692. siLsave_system()
  693. {
  694.     int i;
  695.  
  696. #ifdef AOSVS
  697.  
  698. #endif
  699.     saving_system = TRUE;
  700.     GBC(t_contiguous);
  701.  
  702. #ifdef BSD
  703.     brk(core_end);
  704. #endif
  705.  
  706. #ifdef DGUX
  707.  
  708. #endif
  709.  
  710. #ifdef AOSVS
  711.  
  712.  
  713.  
  714.  
  715. #endif
  716.     cbgbccount = 0;
  717.     rbgbccount = 0;
  718.     for (i = 0;  i < (int)t_end;  i++)
  719.         tm_table[i].tm_gbccount = 0;
  720.     Lsave();
  721.     saving_system = FALSE;
  722.     alloc_page(-(holepage+nrbpage));
  723. }
  724.  
  725. init_main()
  726. {
  727.     make_function("BY", Lby);
  728.     make_function("BYE", Lby);
  729.  
  730.     make_function("IDENTITY", Lidentity);
  731.  
  732.     siStop_level=make_si_ordinary("TOP-LEVEL");
  733.     enter_mark_origin(&siStop_level);
  734.  
  735.     make_si_function("ARGC", siLargc);
  736.     make_si_function("ARGV", siLargv);
  737.  
  738. #ifdef UNIX
  739.     make_si_function("GETENV", siLgetenv);
  740. #endif
  741.  
  742.     make_si_function("MARK-VS", siLmark_vs);
  743.     make_si_function("CHECK-VS", siLcheck_vs);
  744.  
  745.     make_si_function("RESET-STACK-LIMITS", siLreset_stack_limits);
  746.  
  747.     make_si_function("INIT-SYSTEM", siLinit_system);
  748.  
  749.     make_si_function("ADDRESS", siLaddress);
  750.     make_si_function("NANI", siLnani);
  751.  
  752.     make_si_function("INITIALIZATION-FAILURE",
  753.              siLinitialization_failure);
  754.  
  755.     make_function("LISP-IMPLEMENTATION-VERSION",
  756.               Llisp_implementation_version);
  757.  
  758.     siVlisp_maxpages =
  759.     make_si_special("*LISP-MAXPAGES*", make_fixnum(real_maxpage));
  760.  
  761.     siClisp_pagesize =
  762.     make_si_constant("LISP-PAGESIZE", make_fixnum(PAGESIZE));
  763.  
  764.     siVsystem_directory =
  765.     make_si_special("*SYSTEM-DIRECTORY*",
  766.             make_simple_string(system_directory));
  767.  
  768.     make_special("*FEATURES*",
  769.              make_cons(make_ordinary("COMMON"),
  770.              make_cons(make_ordinary("KCL"), Cnil)));
  771.  
  772. #ifdef VAX
  773.     make_special("*FEATURES*",
  774.              make_cons(make_ordinary("VAX"),
  775.              make_cons(make_ordinary("UNIX"),
  776.              make_cons(make_ordinary("BSD"),
  777.              make_cons(make_ordinary("COMMON"),
  778.              make_cons(make_ordinary("KCL"), Cnil))))));
  779. #endif
  780.  
  781. #ifdef SUN
  782.     make_special("*FEATURES*",
  783.              make_cons(make_ordinary("SUN"),
  784.              make_cons(make_ordinary("MC68K"),
  785.              make_cons(make_ordinary("IEEE-FLOATING-POINT"),
  786.              make_cons(make_ordinary("UNIX"),
  787.              make_cons(make_ordinary("BSD"),
  788.              make_cons(make_ordinary("COMMON"),
  789.              make_cons(make_ordinary("KCL"), Cnil))))))));
  790. #endif
  791.  
  792. #ifdef SUN2R3
  793.     make_special("*FEATURES*",
  794.              make_cons(make_ordinary("SUN"),
  795.              make_cons(make_ordinary("MC68K"),
  796.              make_cons(make_ordinary("IEEE-FLOATING-POINT"),
  797.              make_cons(make_ordinary("UNIX"),
  798.              make_cons(make_ordinary("BSD"),
  799.              make_cons(make_ordinary("COMMON"),
  800.              make_cons(make_ordinary("KCL"), Cnil))))))));
  801. #endif
  802.  
  803. #ifdef SUN3
  804.     make_special("*FEATURES*",
  805.              make_cons(make_ordinary("SUN"),
  806.              make_cons(make_ordinary("MC68020"),
  807.              make_cons(make_ordinary("IEEE-FLOATING-POINT"),
  808.              make_cons(make_ordinary("UNIX"),
  809.              make_cons(make_ordinary("BSD"),
  810.              make_cons(make_ordinary("COMMON"),
  811.              make_cons(make_ordinary("KCL"), Cnil))))))));
  812. #endif
  813.  
  814. #ifdef NEWS
  815.     make_special("*FEATURES*",
  816.              make_cons(make_ordinary("NEWS"),
  817.              make_cons(make_ordinary("MC68020"),
  818.              make_cons(make_ordinary("IEEE-FLOATING-POINT"),
  819.              make_cons(make_ordinary("UNIX"),
  820.              make_cons(make_ordinary("BSD"),
  821.              make_cons(make_ordinary("COMMON"),
  822.              make_cons(make_ordinary("KCL"), Cnil))))))));
  823. #endif
  824.  
  825. #ifdef ISI
  826.  
  827.  
  828.  
  829.  
  830.  
  831.  
  832.  
  833.  
  834. #endif
  835.  
  836. #ifdef SEQ
  837.  
  838.  
  839.  
  840.  
  841.  
  842.  
  843.  
  844.  
  845. #endif
  846.  
  847. #ifdef IBMRT
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854. #endif
  855.  
  856. #ifdef ATT3B2
  857.     make_special("*FEATURES*",
  858.              make_cons(make_ordinary("ATT3B2"),
  859.              make_cons(make_ordinary("IEEE-FLOATING-POINT"),
  860.              make_cons(make_ordinary("UNIX"),
  861.              make_cons(make_ordinary("SYSTEM-V"),
  862.              make_cons(make_ordinary("COMMON"),
  863.              make_cons(make_ordinary("KCL"), Cnil)))))));
  864. #endif
  865.  
  866. #ifdef S3000
  867.     make_special("*FEATURES*",
  868.              make_cons(make_ordinary("S3300"),
  869.              make_cons(make_ordinary("UNIX"),
  870.              make_cons(make_ordinary("SYSTEM-V"),
  871.              make_cons(make_ordinary("COMMON"),
  872.              make_cons(make_ordinary("KCL"), Cnil))))));
  873. #endif
  874.  
  875. #ifdef E15
  876.     make_special("*FEATURES*",
  877.              make_cons(make_ordinary("E15"),
  878.              make_cons(make_ordinary("MC68K"),
  879.              make_cons(make_ordinary("IEEE-FLOATING-POINT"),
  880.              make_cons(make_ordinary("UNIX"),
  881.              make_cons(make_ordinary("UNIPLUS-SYSTEM-V"),
  882.              make_cons(make_ordinary("COMMON"),
  883.              make_cons(make_ordinary("KCL"), Cnil))))))));
  884. #endif
  885.  
  886. #ifdef DGUX
  887.  
  888.  
  889.  
  890.  
  891.  
  892.  
  893. #endif
  894.  
  895. #ifdef AOSVS
  896.  
  897.  
  898.  
  899.  
  900.  
  901. #endif
  902.  
  903.     make_si_function("SAVE-SYSTEM", siLsave_system);
  904. }
  905.